// ============================================================================
// 数据验证工具
// ============================================================================

import { 
  SearchTaskParams, 
  UserTaskParams, 
  TrendingTaskParams,
  AppConfig,
  ExportOptions
} from '../types'
import { isValidTaskType, isValidLogLevel, isValidURL, isInRange } from './type-guards'

/** 验证结果 */
export interface ValidationResult {
  isValid: boolean
  errors: string[]
}

/** 创建验证结果 */
export function createValidationResult(isValid: boolean, errors: string[] = []): ValidationResult {
  return { isValid, errors }
}

/** 验证搜索任务参数 */
export function validateSearchTaskParams(params: any): ValidationResult {
  const errors: string[] = []
  
  if (!params || typeof params !== 'object') {
    return createValidationResult(false, ['参数必须是对象'])
  }
  
  // 验证关键词
  if (!params.keyword || typeof params.keyword !== 'string') {
    errors.push('关键词是必需的且必须是字符串')
  } else if (params.keyword.trim().length === 0) {
    errors.push('关键词不能为空')
  } else if (params.keyword.length > 100) {
    errors.push('关键词长度不能超过100个字符')
  }
  
  // 验证搜索类型
  if (params.searchType && !['comprehensive', 'realtime', 'hot'].includes(params.searchType)) {
    errors.push('搜索类型必须是 comprehensive、realtime 或 hot')
  }
  
  // 验证数量
  if (params.count !== undefined) {
    if (typeof params.count !== 'number' || !isInRange(params.count, 1, 1000)) {
      errors.push('数量必须是1-1000之间的数字')
    }
  }
  
  // 验证日期范围
  if (params.dateRange) {
    if (!Array.isArray(params.dateRange) || params.dateRange.length !== 2) {
      errors.push('日期范围必须是包含两个日期的数组')
    } else {
      const [start, end] = params.dateRange
      if (!(start instanceof Date) || !(end instanceof Date)) {
        errors.push('日期范围必须包含有效的日期对象')
      } else if (start >= end) {
        errors.push('开始日期必须早于结束日期')
      }
    }
  }
  
  return createValidationResult(errors.length === 0, errors)
}

/** 验证用户任务参数 */
export function validateUserTaskParams(params: any): ValidationResult {
  const errors: string[] = []
  
  if (!params || typeof params !== 'object') {
    return createValidationResult(false, ['参数必须是对象'])
  }
  
  // 验证用户ID
  if (!params.userId || typeof params.userId !== 'string') {
    errors.push('用户ID是必需的且必须是字符串')
  } else if (params.userId.trim().length === 0) {
    errors.push('用户ID不能为空')
  }
  
  // 验证数量
  if (params.count !== undefined) {
    if (typeof params.count !== 'number' || !isInRange(params.count, 1, 1000)) {
      errors.push('数量必须是1-1000之间的数字')
    }
  }
  
  // 验证日期范围
  if (params.dateRange) {
    if (!Array.isArray(params.dateRange) || params.dateRange.length !== 2) {
      errors.push('日期范围必须是包含两个日期的数组')
    } else {
      const [start, end] = params.dateRange
      if (!(start instanceof Date) || !(end instanceof Date)) {
        errors.push('日期范围必须包含有效的日期对象')
      } else if (start >= end) {
        errors.push('开始日期必须早于结束日期')
      }
    }
  }
  
  return createValidationResult(errors.length === 0, errors)
}

/** 验证热门任务参数 */
export function validateTrendingTaskParams(params: any): ValidationResult {
  const errors: string[] = []
  
  if (!params || typeof params !== 'object') {
    return createValidationResult(false, ['参数必须是对象'])
  }
  
  // 验证分类
  if (params.category && !['all', 'entertainment', 'sports', 'tech'].includes(params.category)) {
    errors.push('分类必须是 all、entertainment、sports 或 tech')
  }
  
  // 验证数量
  if (params.count !== undefined) {
    if (typeof params.count !== 'number' || !isInRange(params.count, 1, 100)) {
      errors.push('数量必须是1-100之间的数字')
    }
  }
  
  return createValidationResult(errors.length === 0, errors)
}

/** 验证应用配置 */
export function validateAppConfig(config: any): ValidationResult {
  const errors: string[] = []
  
  if (!config || typeof config !== 'object') {
    return createValidationResult(false, ['配置必须是对象'])
  }
  
  // 验证爬虫配置
  if (config.crawler) {
    const { crawler } = config
    
    if (crawler.maxConcurrency !== undefined) {
      if (typeof crawler.maxConcurrency !== 'number' || !isInRange(crawler.maxConcurrency, 1, 10)) {
        errors.push('最大并发数必须是1-10之间的数字')
      }
    }
    
    if (crawler.requestDelay !== undefined) {
      if (typeof crawler.requestDelay !== 'number' || !isInRange(crawler.requestDelay, 100, 10000)) {
        errors.push('请求延迟必须是100-10000毫秒之间的数字')
      }
    }
    
    if (crawler.retryAttempts !== undefined) {
      if (typeof crawler.retryAttempts !== 'number' || !isInRange(crawler.retryAttempts, 0, 5)) {
        errors.push('重试次数必须是0-5之间的数字')
      }
    }
    
    if (crawler.timeout !== undefined) {
      if (typeof crawler.timeout !== 'number' || !isInRange(crawler.timeout, 5000, 120000)) {
        errors.push('超时时间必须是5000-120000毫秒之间的数字')
      }
    }
  }
  
  // 验证代理配置
  if (config.proxy) {
    const { proxy } = config
    
    if (proxy.enabled !== undefined && typeof proxy.enabled !== 'boolean') {
      errors.push('代理启用状态必须是布尔值')
    }
    
    if (proxy.rotationInterval !== undefined) {
      if (typeof proxy.rotationInterval !== 'number' || !isInRange(proxy.rotationInterval, 60000, 3600000)) {
        errors.push('代理轮换间隔必须是60000-3600000毫秒之间的数字')
      }
    }
    
    if (proxy.servers && !Array.isArray(proxy.servers)) {
      errors.push('代理服务器列表必须是数组')
    }
  }
  
  // 验证存储配置
  if (config.storage) {
    const { storage } = config
    
    if (storage.dataPath !== undefined && typeof storage.dataPath !== 'string') {
      errors.push('数据路径必须是字符串')
    }
    
    if (storage.maxFileSize !== undefined) {
      if (typeof storage.maxFileSize !== 'number' || !isInRange(storage.maxFileSize, 1024 * 1024, 1024 * 1024 * 1024)) {
        errors.push('最大文件大小必须是1MB-1GB之间的数字')
      }
    }
    
    if (storage.retentionDays !== undefined) {
      if (typeof storage.retentionDays !== 'number' || !isInRange(storage.retentionDays, 1, 365)) {
        errors.push('数据保留天数必须是1-365之间的数字')
      }
    }
  }
  
  // 验证日志配置
  if (config.logging) {
    const { logging } = config
    
    if (logging.level !== undefined && !isValidLogLevel(logging.level)) {
      errors.push('日志级别必须是 debug、info、warn 或 error')
    }
    
    if (logging.maxFiles !== undefined) {
      if (typeof logging.maxFiles !== 'number' || !isInRange(logging.maxFiles, 1, 20)) {
        errors.push('最大日志文件数必须是1-20之间的数字')
      }
    }
  }
  
  return createValidationResult(errors.length === 0, errors)
}

/** 验证导出选项 */
export function validateExportOptions(options: any): ValidationResult {
  const errors: string[] = []
  
  if (!options || typeof options !== 'object') {
    return createValidationResult(false, ['导出选项必须是对象'])
  }
  
  // 验证格式
  if (!options.format || !['json', 'csv', 'xlsx'].includes(options.format)) {
    errors.push('导出格式必须是 json、csv 或 xlsx')
  }
  
  // 验证字段
  if (options.fields && !Array.isArray(options.fields)) {
    errors.push('字段列表必须是数组')
  }
  
  // 验证最大记录数
  if (options.maxRecords !== undefined) {
    if (typeof options.maxRecords !== 'number' || !isInRange(options.maxRecords, 1, 100000)) {
      errors.push('最大记录数必须是1-100000之间的数字')
    }
  }
  
  return createValidationResult(errors.length === 0, errors)
}

/** 验证账号ID */
export function validateAccountId(accountId: any): ValidationResult {
  if (!accountId || typeof accountId !== 'string') {
    return createValidationResult(false, ['账号ID必须是非空字符串'])
  }
  
  if (accountId.trim().length === 0) {
    return createValidationResult(false, ['账号ID不能为空'])
  }
  
  return createValidationResult(true)
}

/** 验证任务ID */
export function validateTaskId(taskId: any): ValidationResult {
  if (!taskId || typeof taskId !== 'string') {
    return createValidationResult(false, ['任务ID必须是非空字符串'])
  }
  
  if (taskId.trim().length === 0) {
    return createValidationResult(false, ['任务ID不能为空'])
  }
  
  return createValidationResult(true)
}
